\newpage
\section{Explorer3d et RGL}
\subsection{L'interaction souris}
\paragraph{}
Au sein d'Explorer3d la partie Java3d permet de visualiser, mais aussi de manipuler les éléments présents dans la scène afin de mieux visualiser les différents éléments. Ces éléments qui permettent d'intéragir avec la scène sont en partie intégrés dans RGL de façon native. En effet les évènements liés à la souris sont par défaut liés aux rotations dans la scène ainsi qu'au zoom et dé-zoom.

\paragraph{}
Cependant, la sélection d'éléments afin de les isoler ou pouvoir les étudier séparément n'est pas implantée dans la fenêtre de base de RGL. Il était donc essentiel de vérifier si des outils permettant ce genre d'interactions existaient. Et si oui comment fonctionnaient-ils afin de pouvoir les intégrer à un projet plus imposant, notament à une interface RGtk2.

\begin{center}
\includegraphics[scale=0.3]{sel_exp.png}\\
\textit{selection d'éléments au sein d'exlorer3d}
\end{center}


\newpage
\subsection{Introduction}
\paragraph{}
Cette partie se concentrera sur l'aspect RGL (des scènes 3d donc) du portage sous R d'Explorer3d.

\paragraph{}
Dans les pages qui suivent nous allons détailler quels sont les outils présents afin de réaliser des interactions entre l'utilisateur et RGL. Nous verrons également quels sont les documents et tutoriels trouvables dans RGL et sur le net ainsi que les fonctionnalités que nous pourront ré-utiliser. Enfin nous verrons quelques exemples simples d'application intégrant RGL et RGtk2.

\paragraph{}
Afin de pouvoir comparer les différents éléments que nous avons put trouver, nous prendrons comme exemple réccurent un nombre de 1000 sphères ou points affichés dans la scène de RGL.

\paragraph{}
Egalement nous préciserons plusieurs points techniques qui nous ont facilités l'utilisation de l'interaction de la fenetre RGL. Il s'agira là toutefois d'exemples illustrant ce qui est possible de faire avec cet outils. D'autres solutions sont possibles et nous les aborderons, mais nous pensons qu'elles ne sont pas à privilégier.


\newpage
\section{RGL : Interactions}
\subsection{Les outils fournis par RGL}


\paragraph{} Au sein de rgl l'évènement par défaut pour le click droit est lié au zoom et dézoom de la scène, le click gauche à la rotation de la scène.

\paragraph{}
Néanmoins nous avons trouvés deux fonctions déjà intégrées au sein de rgl permettant d'effectuer des sélections au sein de la scène 3d via la souris.

\paragraph{Select3d}
\paragraph{} Cette fonction est bloquante. Elle renvoie une fonction de vecteurs (x,y,z) contenant les coordonnées des points où sélectionnés par l'utilisateur. 
\\ \\
voir http://www.inside-r.org/packages/cran/rgl/docs/select3d

\paragraph{}
voici un code d'exemple d'utilisation de select3d : \\

\begin{lstlisting}
	x <- rnorm(1000)
	y <- rnorm(1000)
	z <- rnorm(1000)
	open3d()
	points3d(x,y,z)
	f <- select3d()
	keep <- f(x,y,z)
	rgl.pop()
	points3d(x[keep],y[keep],z[keep],color="red")
	points3d(x[!keep],y[!keep],z[!keep])
\end{lstlisting} 

\paragraph{}
Dans cet exemple nous chargeons une scene 3d avec un nuage de points. L'appel a select3d est bloquant jusqu'a ce que l'utilisateur effectue une sélection dans le nuage de points. Il recharge ensuite le nuage, colorant en rouge la selection effectuée.

\paragraph{}
Il est donc possible de sélectionner des objets dans une fenêtre rgl.

\newpage
\paragraph{Selectpoints3d}
\paragraph{} Cette fonction est également bloquante. Elle attends en paramètres la liste complète des éléments présents dans la scène. Elle utilise ensuite la fonction select3d pour déterminer quels éléments sont dans la sélection et les renvoyer. Elle permet également de selectionner non pas une région de la scène mais un point précis.
\\ \\
voir http://www.inside-r.org/packages/cran/rgl/docs/selectpoints3d

\paragraph{}
voici un code d'exemple d'utilisation de selectpoints3d  : 

\begin{lstlisting}
	ids <- plot3d( rnorm(20), rnorm(20), rnorm(20) )
  
	selectpoints3d(ids["data"], 
		multiple = function(x) {
		spheres3d(x, color = "red", alpha = 0.3, radius = 0.2)
		TRUE
	})
\end{lstlisting}

\vspace{1cm}

\begin{center}
\includegraphics[scale=0.7]{selectpoints3d.png}\\
\textit{Selection de 5 sphères dans rgl via Selectpoints3d}
\end{center}

\paragraph{}
Néanmoins, après plusieurs tests, il apparait que cette fonction ne permet pas de sélectionner un élément unique lorsque la scène est par exemple composée de sphères ou de nuages de points non définis par plot3d, ce qui se révèle assez problématique pour avoir un code souple. 


\newpage
\subsection{RGL - Sculpt3d}

\paragraph{}
Il existe également un package pour rgl qui permet de simplifier la sélection de divers objets de la fenêtre rgl. Celui-ci inclus une toolbar rgtk afin de nottament résoudre le problème de conflits sur l'évenement de clic gauche de la souris - fonctions bloquantes et impossibilités de rappel de la fonction. En sélectionnant l'option adéquat dans la barre rgtk l'utilisateur peut réactiver à loisir la sélection d'objets 3d, la fonction de rotation reprenant la priorité sur la sélection après chaque utilisation.

\paragraph{}
Voici le code R appelé lors de l'execution du fichier de démo de sculpt3d : \\ \\ \\ \\


\begin{lstlisting}
x <- sort(rnorm(1000))
y <- rnorm(1000)
z <- rnorm(1000) + atan2(x,y)
sculpt3d(x, y, z, col=rainbow(1000), 
	type='s', alpha = .5, radius = runif(1000)/5)
\end{lstlisting}

\vspace{5mm}

\begin{center}
\includegraphics[scale=0.2]{sculpt3d.png}\\
\textit{Selection d'une région dans sculpt3d}
\end{center}

\paragraph{}
Celui-ci charge la barre d'outils ainsi qu'une fenetre rgl contenant 1000 élèments de différentes couleurs.

\paragraph{}
Cette barre d'outils inclus également plusieurs options, tels que la suppression des éléments actuellement sélectionnés, la re-coloration des éléments sélectionnés et l'isolation des éléments sélectionnés.

\paragraph{}
Ce package rempli ainsi une partie des interactions principales présentes dans explorer3d, excepté la loupe. Ses fonctionalités ne peuvent cependant pas être intégrées en une seule fenêtre sans modifier le code source du package.

\paragraph{}
Le code source de Sculpt3d est accessible et les autres fonctionnalités d'Explorer3d pourraient donc y être ajoutées, comme l'explorateur de fichiers par exemple. Cela impliquerait de coder cette intégration, mais c'est une tâche qui peut être réalisée, bien que fastidieuse.

\paragraph{}
Nous avons également cherché d'autres outils pouvant servir d'alternatives à sculpt3d, mais il apparaît que ce package a actuellement le monopole de ce type de fonctionnalités. Les tutoriels basés sur ce package étant assez peu nombreux, pour ne pas dire inexistant hormis la brève documentation fournie, il est nécessaire d'étudier le code source du package afin de ne pas avoir à ré-inventer du code déjà existant.

%\newpage
\subsection{RGL et RGtk2}
\paragraph{}
Après avoir étudié le code source de Select3d, il apparait que seule la fonction select3d est utilisée dans ce package, probablement pour des raisons de portabilités. Entre select3d et selectpoints3d, c'est la première fonction que nous recommandons d'utiliser afin de pouvoir interagir avec la scène. 

\paragraph{}
Un autre avantage de select3d est apparu lors des tests d'interaction entre rgl et rgtk2. Selectpoints3d supporte mal la cohabitation, et les selections réalisées ne sont pas actualisées correctement.

\paragraph{}
Voici donc deux exemples légers réalisés, imitant le principe de Sculpt3d : une fenetre rgtk2 qui permet de faire apparaitre la scène et d'activer la sélection.
\\ \\
\begin{center}
\includegraphics[scale=0.5]{nuage.png}\\
\textit{Selection d'un nuage de points via rgtk2}
\end{center}

\vspace{1cm}

\begin{center}
\includegraphics[scale=0.5]{spheres.png}\\
\textit{Selection de spheres via rgtk2}
\end{center}

\paragraph{}
Et voici le code permettant d'interagir avec les fonctions de rgtk2 comme l'illustre la capture d'écran précédente :

\begin{lstlisting}
fn_btn_1 <-function(button,user.data){
	open3d()
	rgl.bg(color="black")
	rgl.spheres(.datac$x,.datac$y,.datac$z,
		.datac$radius,.datac$color)
}

fn_btn_2 <-function(button,user.data){
	f<-rgl.select3d() 
	keep<-f(.datac$x,.datac$y,.datac$z) 
	rgl.pop()
	rgl.spheres(.datac$x[keep],.datac$y[keep],.datac$z[keep],
		.datac$radius[keep],color="red")
	rgl.spheres(.datac$x[!keep],.datac$y[!keep],.datac$z[!keep],
		.datac$radius[!keep],.datac$color[!keep])
}

\end{lstlisting}

\paragraph{}
En complexifiant l'exemple précédent, nous pouvons commencer à nous rapprocher d'outils présent au sein d'Explorer3d, comme par exemple avoir les objets sélectionnés dans une vue et les objets non sélectionnés dans une seconde.

\paragraph{}
Via la conservation des identifiants des differentes fenetres au sein d'une variable globale offrant une similitude avec les langages orientés objets. Ainsi il est possible de gérer plusieurs fenêtres et d'interagir avec celles-ci, le tout paramétré par l'outil rgtk2.
\\ \\
\begin{center}
\includegraphics[scale=0.5]{doublefen.png}\\
\textit{Interactions entre RGL et RGtk2}
\end{center}
\vspace{1cm}

\paragraph{}
En exploitant l'environnement global, il est simple de gérer les fenetres affichées et de savoir quelle est la fenetre active : 

\begin{lstlisting}
# declaration de l'environnement
.monEnv <- new.env()

# stockage dans l'environnement de l'identifiant de la fenetre 
# rgl a l'ouverture de celle-ci
.monEnv$idfen <- open3d() 

# charge comme fenetre active la fenetre dont l'identifiant
# a auparavant ete stocke dans l'environnement
rgl.set(.monEnv$idfen)
\end{lstlisting}

\newpage
\subsection{Problèmes RGL à éviter}
\paragraph{Selection vide}
\paragraph{} Un problème auquel nous avons été confrontés lors des études d'interaction avec RGL a été l'apparition d'erreurs lors de l'affichage des sphères. En effet, lorsque l'utilisateur effectue une sélection vide dans la scène RGL, des vecteurs vides sont transmis aux fonctions d'affichage ce qui entraine ces problèmes.

\paragraph{}
C'est pourquoi il est nécessaire lors de la sélection de select3d de vérifier que celle-ci comporte au moins un élèment (ou de vérifier lors de chaque affichage d'objets que les vecteurs transmis ne sont pas vide).

\paragraph{Affichage en multi-vues}
\paragraph{} Comme nous en avons parlés dans la section précédente lorsque nous présentions l'interaction entre rgl et rgtk2, il est nécessaire de gérer les scènes rgl afin de ne pas créer de nouvelles fenêtres à chaque évenements. La fonction rgl.pop() qui permet de vider une scène courante est alors à utiliser avant de charger à nouveau les éléments attendus dans la scène concernée.

\subsection{Sources}
\paragraph{}
Il n'y a aucun tutoriel en ligne en dehors de la documentation RGL et de la documentation de Sculpt3d. La majeure partie des expérimentations d'interactions avec la scène RGL ont été effectuées en expérimentant à la volée des tests de sélection et d'interaction. Le code-source de Scultp3d, bien que complexe, a toutefois permis de cerner certaines spécificités de ce genre d'interactions.
\\ \\
http://cran.r-project.org/web/packages/rgl/rgl.pdf
\\ \\
http://www.inside-r.org/packages/cran/sculpt3d


